//枚举 枚举属性默认从0开始递增，可设置初始值
// enum Directive {
//       Up,
//       Down,
//       Left,
//       Right
//   }
//   function fn(directive: Directive){
//     console.log(directive)
// }
// fn(Directive.Down)



// //typeof
// let obj={name:'1',age:19}
// function fn(option:typeof obj){
//     console.log(option);   
// }

//class类
// class Person{
//     name:string
//     age:number
//     constructor(name:string,age:number){
//         this.name=name
//         this.age=age
//     }
// }

// //继承
// class Student extends Person{
    
// }
// let s=new Student('张三',19)
// console.log(s.age);
// console.log(s.name);

//接口继承
// interface Ptype{
//     name:string
//     age:number
// }

// class Person implements Ptype{
//     name: string='张三';
//     age=19;
// }


//修饰符
/*
1、public 默认值，公共，公开
2、protected 保护的,仅声明所在类和子类中可见可调用
3、private: 私有的，仅声明所在类中可见可调用
4、readonly: 只读，只能通过参数赋值，无法在函数外进行修改赋值
*/

// class Father{
//     readonly age:number
//     constructor(age:number){
//         this.age=age
//         this.init()
//     }
//     init(){
//         console.log(this.age);   
//     }
// }
//  let f=new Father(19)
// // f.age=20



//抽象类：将类作为接口使用，该类无法实例化
//语法: abstract class 类名{属性：属性类名='初始值' 属性：属性类名='初始值'...}


//泛型：后确定类型，可用于接口和类


    // function fn<T>(a:T,b:T){
    //     console.log(a,b)
    // }
    // fn<number>(19,29)/fn(19.29)



//装饰器
/* 
    语法：function 函数名(变量：any){
        变量.prototype.play=function(){}    
    }
    调用：
    @函数名
    class 对象名{}
*/

/*
function  Play(target:any){
    target.prototype.play=function(){
        console.log('耍');
        
    }
}
function  Study(target:any){
    target.prototype.Study=function(){
        console.log('学');
        
    }
}
function  Sleep(target:any){
    target.prototype.Sleep=function(){
        console.log('睡');
    }
}


@Play
class person{}

@Play
@Sleep
class student{}

@Play
@Sleep
@Study
class teacher{}

console.log(new person(),new student(),new teacher());
*/

